/**
 * 消息相关API接口
 */

import request from '../utils/request.js'

export const messageApi = {
  /**
   * 获取会话列表
   * @param {Object} params - 查询参数
   * @param {number} params.page - 页码
   * @param {number} params.limit - 每页数量
   * @param {string} params.type - 会话类型（private/group）
   */
  getConversations(params = {}) {
    // 自动补齐用户名
    if (!params || !params.userId) {
      try {
        const userInfo = uni.getStorageSync('userInfo')
        // const username = userInfo?.username || userInfo?.nickname || userInfo?.email
        const userId = userInfo?.id || userInfo?.userId
        if (userId) {
          params = { ...params, userId }
        }
      } catch (e) {
        // ignore
      }
    }
    return request.get('/user/api/chat/conversations', params)
  },

  /**
   * 获取聊天消息列表
   * @param {Object} params - 查询参数
   * @param {string} params.user1 - 用户1
   * @param {string} params.user2 - 用户2
   * @param {number} params.page - 页码
   * @param {number} params.size - 每页数量
   */
  getChatMessages(params = {}) {
    return request.get('/user/api/chat/messages', params)
  },

  /**
   * 发送消息（通过WebSocket）
   * @param {Object} data - 消息数据
   * @param {string} data.toName - 接收者用户名
   * @param {string} data.message - 消息内容
   */
  sendMessage(data) {
    // WebSocket发送，这里只是占位
    // 实际发送在WebSocket类中实现
    return Promise.resolve(data)
  },

  /**
   * 撤回消息
   * @param {string} messageId - 消息ID
   */
  recallMessage(messageId) {
    return request.put(`/user/messages/${messageId}/recall`)
  },

  /**
   * 删除消息
   * @param {string} messageId - 消息ID
   */
  deleteMessage(messageId) {
    return request.delete(`/user/messages/${messageId}`)
  },

  /**
   * 标记消息已读
   * @param {string} conversationId - 会话ID
   * @param {string} messageId - 消息ID（可选，不传则标记整个会话已读）
   */
  // 兼容旧接口占位，建议使用 markMessagesAsRead
  markMessageAsRead(conversationId, messageId) {
    const data = messageId ? { messageId } : {}
    return request.put(`/user/messages/conversations/${conversationId}/read`, data)
  },

  /**
   * 标记某个对端发来的消息为已读（基于用户名）
   * @param {string} fromUser 发送者（对端用户名）
   * @param {string} toUser 接收者（当前用户）
   */
  // markMessagesAsRead(fromUser, toUser) {
  //   return request.post('/user/api/chat/mark-read', { fromUser, toUser })
  // },
  //
  // /**
  //  * 标记某个对端发来的消息为已读（基于用户ID）
  //  * @param {number} fromUserId 发送者用户ID
  //  * @param {number} toUserId 接收者用户ID
  //  */
  // markMessagesAsReadByIds(fromUserId, toUserId) {
  //   // 使用params参数，让request工具自动处理为URL参数
  //   return request.post('/user/api/chat/mark-read-by-ids', null, {
  //     params: { fromUserId, toUserId }
  //   })
  // },

  /**
   * 标记会话已读
   * @param {string} conversationId - 会话ID
   */
  // 兼容旧接口占位
  markConversationAsRead(conversationId) {
    return request.put(`/user/messages/conversations/${conversationId}/read`)
  },

  /**
   * 置顶/取消置顶会话
   * @param {string} conversationId - 会话ID
   * @param {boolean} pinned - 是否置顶
   */
  togglePinConversation(conversationId, pinned = true) {
    return request.put(`/user/messages/conversations/${conversationId}/pin`, { pinned })
  },

  /**
   * 设置会话免打扰
   * @param {string} conversationId - 会话ID
   * @param {boolean} muted - 是否免打扰
   */
  muteConversation(conversationId, muted = true) {
    return request.put(`/user/messages/conversations/${conversationId}/mute`, { muted })
  },

  /**
   * 删除会话
   * @param {string} conversationId - 会话ID
   * @param {boolean} deleteMessages - 是否同时删除消息记录
   */
  deleteConversation(conversationId, deleteMessages = true) {
    return request.delete(`/user/messages/conversations/${conversationId}`, { deleteMessages })
  },

  /**
   * 清空会话消息
   * @param {string} conversationId - 会话ID
   */
  clearConversationMessages(conversationId) {
    return request.delete(`/user/messages/conversations/${conversationId}/messages`)
  },

  /**
   * 获取未读消息数量
   */
  getUnreadMessageCount(params = {}) {
    // 自动补齐用户ID或用户名
    if (!params || (!params.userId && !params.username)) {
      try {
        const userInfo = uni.getStorageSync('userInfo')
        const userId = userInfo?.id || userInfo?.userId
        const username = userInfo?.username || userInfo?.nickname || userInfo?.email

        if (userId) {
          params = { ...params, userId }
        } else if (username) {
          params = { ...params, username }
        }
      } catch (e) {
        // ignore
      }
    }
    return request.get('/user/api/chat/unread-count', params)
  },

  /**
   * 获取系统通知列表
   * @param {Object} params - 查询参数
   */
  getNotifications(params = {}) {
    return request.get('/user/messages/notifications', params)
  },

  /**
   * 获取通知未读数量
   */
  getNotificationCount() {
    return request.get('/user/messages/notifications/count')
  },

  /**
   * 标记通知已读
   * @param {string} notificationId - 通知ID
   */
  markNotificationAsRead(notificationId) {
    return request.put(`/user/messages/notifications/${notificationId}/read`)
  },

  /**
   * 批量标记通知已读
   * @param {Array} notificationIds - 通知ID数组
   */
  markNotificationsAsRead(notificationIds) {
    return request.put('/user/messages/notifications/batch-read', { notificationIds })
  },

  // 批量删除通知
  batchDeleteNotifications(notificationIds) {
    return request.delete('/user/messages/notifications/batch', { notificationIds })
  },

  // 清空所有通知
  clearAllNotifications() {
    return request.delete('/user/messages/notifications')
  },

  /**
   * 清空所有聊天记录
   * @param {string} username - 用户名
   */
  clearAllChatMessages(username) {
    return request.delete(`/user/api/chat/clear-all?username=${encodeURIComponent(username)}`)
  },

  // ========== 群聊消息相关接口 ==========

  /**
   * 获取群聊消息记录
   * @param {Object} params - 查询参数
   * @param {number} params.groupId - 群组ID
   * @param {number} params.page - 页码
   * @param {number} params.size - 每页数量
   */
  getGroupChatMessages(params = {}) {
    return request.get('/user/api/group-chat/messages', params)
  },

  /**
   * 获取群聊最新消息
   * @param {Object} params - 查询参数
   * @param {number} params.groupId - 群组ID
   */
  getGroupLatestMessage(params = {}) {
    return request.get('/user/api/group-chat/latest', params)
  },

  /**
   * 保存群聊消息
   * @param {Object} data - 消息数据
   */
  saveGroupMessage(data) {
    return request.post('/user/api/group-chat/save', data)
  },

  /**
   * 批量保存群聊消息
   * @param {Array} data - 消息数组
   */
  batchSaveGroupMessages(data) {
    return request.post('/user/api/group-chat/batch-save', data)
  },

  /**
   * 删除群聊消息
   * @param {string} messageId - 消息ID
   */
  deleteGroupMessage(messageId) {
    return request.delete(`/user/api/group-chat/${messageId}`)
  },

  /**
   * 获取群聊消息总数
   * @param {Object} params - 查询参数
   * @param {number} params.groupId - 群组ID
   */
  getGroupMessageCount(params = {}) {
    return request.get('/user/api/group-chat/count', params)
  },

  // ========== 图片上传相关接口 ==========

  /**
   * 上传聊天图片
   * @param {Object} data - 上传数据
   * @param {string} data.fromUser - 发送者用户名
   * @param {string} data.toUser - 接收者用户名（可选）
   * @param {File} data.file - 图片文件
   */
  uploadChatImage(data) {
    return request.upload('/user/api/chat/image/upload', data.file, {
      name: 'file',
      formData: {
        fromUser: data.fromUser,
        toUser: data.toUser || ''
      }
    })
  },

  /**
   * 上传聊天视频
   * @param {Object} data - 上传数据
   * @param {string} data.fromUser - 发送者用户名
   * @param {string} data.toUser - 接收者用户名（可选）
   * @param {File} data.file - 视频文件
   */
  uploadChatVideo(data) {
    return request.upload('/user/api/chat/video/upload', data.file, {
      name: 'file',
      formData: {
        fromUser: data.fromUser,
        toUser: data.toUser || ''
      }
    })
  },

  /**
   * 删除聊天图片
   * @param {string} objectName - 对象名称
   */
  deleteChatImage(objectName) {
    return request.delete(`/user/api/chat/image/${objectName}`)
  },

  // ========== 搜索相关接口 ==========

  /**
   * 综合搜索（联系人、群聊、聊天记录）
   * @param {Object} params - 搜索参数
   * @param {string} params.keyword - 搜索关键词
   * @param {string} params.type - 搜索类型（all/contacts/groups/messages）
   */
  searchAll(params = {}) {
    // 自动补齐用户信息
    if (!params.userId && !params.username) {
      try {
        const userInfo = uni.getStorageSync('userInfo')
        const userId = userInfo?.id || userInfo?.userId
        const username = userInfo?.username || userInfo?.nickname || userInfo?.email

        if (userId) {
          params = { ...params, userId }
        } else if (username) {
          params = { ...params, username }
        }
      } catch (e) {
        // ignore
      }
    }
    // 添加静默处理标识
    return request.get('/user/api/search/all', params, { silent: true })
  },

  /**
   * 搜索聊天记录
   * @param {Object} params - 搜索参数
   * @param {string} params.keyword - 搜索关键词
   * @param {string} params.username - 当前用户名
   * @param {number} params.page - 页码
   * @param {number} params.size - 每页数量
   */
  searchMessages(params = {}) {
    // 自动补齐用户信息
    if (!params.userId && !params.username) {
      try {
        const userInfo = uni.getStorageSync('userInfo')
        const userId = userInfo?.id || userInfo?.userId
        const username = userInfo?.username || userInfo?.nickname || userInfo?.email

        if (userId) {
          params = { ...params, userId }
        } else if (username) {
          params = { ...params, username }
        }
      } catch (e) {
        // ignore
      }
    }
    return request.get('/user/api/search/messages', params)
  }
}

export default messageApi